package com.monitor.security;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Properties;

/**
 * 密码管理器，用于处理系统密码的验证和修改
 */
public class PasswordManager {
    private static final String DEFAULT_PASSWORD = "112233"; // 默认密码
    private static final String CONFIG_FILE = "config.properties";
    private static final String PASSWORD_KEY = "password";
    
    private String passwordHash;
    private File configFile;
    
    public PasswordManager() {
        // 初始化配置文件路径
        String userHome = System.getProperty("user.home");
        String configDir = userHome + File.separator + ".monitor";
        new File(configDir).mkdirs(); // 确保目录存在
        configFile = new File(configDir, CONFIG_FILE);
        
        // 加载或初始化密码
        loadPassword();
    }
    
    /**
     * 加载密码，如果配置文件不存在则创建默认密码
     */
    private void loadPassword() {
        if (!configFile.exists()) {
            // 如果配置文件不存在，创建默认密码
            passwordHash = hashPassword(DEFAULT_PASSWORD);
            savePassword();
        } else {
            // 从配置文件加载密码哈希
            Properties props = new Properties();
            try (FileInputStream fis = new FileInputStream(configFile)) {
                props.load(fis);
                passwordHash = props.getProperty(PASSWORD_KEY);
                if (passwordHash == null || passwordHash.isEmpty()) {
                    // 如果密码为空，设置默认密码
                    passwordHash = hashPassword(DEFAULT_PASSWORD);
                    savePassword();
                }
            } catch (IOException e) {
                e.printStackTrace();
                // 出错时设置默认密码
                passwordHash = hashPassword(DEFAULT_PASSWORD);
            }
        }
    }
    
    /**
     * 保存密码到配置文件
     */
    private void savePassword() {
        Properties props = new Properties();
        props.setProperty(PASSWORD_KEY, passwordHash);
        
        try (FileOutputStream fos = new FileOutputStream(configFile)) {
            props.store(fos, "Monitor Password Configuration");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    
    /**
     * 验证密码是否正确
     * @param password 要验证的密码
     * @return 如果密码正确返回true，否则返回false
     */
    public boolean verifyPassword(String password) {
        if (password == null || password.isEmpty()) {
            return false;
        }
        
        String inputHash = hashPassword(password);
        return inputHash.equals(passwordHash);
    }
    
    /**
     * 修改密码
     * @param oldPassword 旧密码
     * @param newPassword 新密码
     * @return 如果修改成功返回true，否则返回false
     */
    public boolean changePassword(String oldPassword, String newPassword) {
        // 验证旧密码
        if (!verifyPassword(oldPassword)) {
            return false;
        }
        
        // 验证新密码有效性
        if (newPassword == null || newPassword.isEmpty()) {
            return false;
        }
        
        // 更新密码哈希并保存
        passwordHash = hashPassword(newPassword);
        savePassword();
        return true;
    }
    
    /**
     * 重置密码为默认密码
     */
    public void resetPassword() {
        passwordHash = hashPassword(DEFAULT_PASSWORD);
        savePassword();
    }
    
    /**
     * 对密码进行哈希处理
     * @param password 原始密码
     * @return 哈希后的密码字符串
     */
    private String hashPassword(String password) {
        try {
            MessageDigest md = MessageDigest.getInstance("SHA-256");
            byte[] hash = md.digest(password.getBytes());
            
            // 将字节数组转换为十六进制字符串
            StringBuilder hexString = new StringBuilder();
            for (byte b : hash) {
                String hex = Integer.toHexString(0xff & b);
                if (hex.length() == 1) {
                    hexString.append('0');
                }
                hexString.append(hex);
            }
            
            return hexString.toString();
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
            // 如果哈希算法不可用，简单地返回密码本身（不推荐用于生产环境）
            return password;
        }
    }
    
    /**
     * 获取默认密码
     * @return 默认密码
     */
    public static String getDefaultPassword() {
        return DEFAULT_PASSWORD;
    }
}